001    /*
002     * Copyright 2006 Stephen J. McConnell.
003     *
004     * Licensed  under the  Apache License,  Version 2.0  (the "License");
005     * you may not use  this file  except in  compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     *   http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed  under the  License is distributed on an "AS IS" BASIS,
012     * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY KIND, either  express  or
013     * implied.
014     *
015     * See the License for the specific language governing permissions and
016     * limitations under the License.
017     */
018    
019    package net.dpml.component;
020    
021    import java.io.IOException;
022    import java.net.URI;
023    import java.lang.ref.WeakReference;
024    
025    import net.dpml.lang.Classpath;
026    import net.dpml.lang.Info;
027    import net.dpml.lang.Part;
028    
029    import net.dpml.util.Logger;
030    
031    /**
032     * Component composition.
033     *
034     * @author <a href="http://www.dpml.net">Digital Product Meta Library</a>
035     * @version 1.0.1
036     */
037    public abstract class Composition extends Part implements Directive
038    {
039        private final Directive m_directive;
040        private final Controller m_controller;
041        
042        private transient WeakReference m_model;
043        
044       /**
045        * Creation of a new abstract composition instance.
046        * @param logger the assigned logging channel
047        * @param info the part info descriptor
048        * @param classpath the part classpath definition
049        * @param controller the part controller
050        * @param directive the part deployment strategy directive
051        * @param label debug label
052        * @exception IOException if an I/O error occurs
053        */
054        public Composition( 
055          Logger logger, Info info, Classpath classpath, Controller controller, 
056          Directive directive, String label ) throws IOException
057        {
058            super( logger, info, classpath, label );
059            
060            if( null == directive )
061            {
062                throw new NullPointerException( "directive" );
063            }
064            m_directive = directive;
065            m_controller = controller;
066        }
067        
068       /**
069        * Return the assigned controller.
070        * @return the controller
071        */
072        public Controller getController()
073        {
074            return m_controller;
075        }
076    
077       /**
078        * Return the part content or null if the result type is unresolvable 
079        * relative to the supplied class argument. Class types recognized over and 
080        * above the Part class include Directive, Model, Component and Controller.
081        *
082        * @param c the content class
083        * @return the content
084        * @exception IOException if an IO error occurs
085        */
086        protected Object getContent( Class c ) throws IOException
087        {
088            if( Directive.class.isAssignableFrom( c ) )
089            {
090                return m_directive;
091            }
092            else if( Model.class.isAssignableFrom( c ) )
093            {
094                return getModel();
095            }
096            else if( Component.class.isAssignableFrom( c ) )
097            {
098                return newComponent();
099            }
100            else if( Controller.class.isAssignableFrom( c ) )
101            {
102                return m_controller;
103            }
104            else
105            {
106                return super.getContent( c );
107            }
108        }
109        
110       /**
111        * Get the deployment directive.
112        * @return the deployment directive
113        */
114        public Directive getDirective()
115        {
116            return m_directive;
117        }
118        
119       /**
120        * Get the deployment model.
121        * @return the deployment model
122        */
123        public Model getModel()
124        {
125            if( null != m_model )
126            {
127                Model model = (Model) m_model.get();
128                if( null != model )
129                {
130                    return model;
131                }
132            }
133            try
134            {
135                Model model = m_controller.createModel( this );
136                m_model = new WeakReference( model );
137                return model;
138            }
139            catch( Throwable e )
140            {
141                URI uri = m_controller.getURI();
142                final String error = 
143                  "Unexpected error while attempting to create a component model."
144                  + "\nDirective: " + m_directive;
145                throw new ControlRuntimeException( uri, error, e );
146            }
147        }
148        
149       /**
150        * Create and return a new component using the deplyment model established by the part.
151        * @return the component
152        */
153        public Component newComponent()
154        {
155            Model model = getModel();
156            try
157            {
158                return m_controller.createComponent( model );
159            }
160            catch( Throwable e )
161            {
162                URI uri = m_controller.getURI();
163                final String error = 
164                  "Unexpected error while attempting to create a component."
165                  + "\nDirective: " + m_directive;
166                throw new ControlRuntimeException( uri, error, e );
167            }
168        }
169        
170       /**
171        * Instantiate a value.
172        * @param args supplimentary arguments
173        * @return the resolved instance
174        * @exception Exception if a deployment error occurs
175        */
176        public Object instantiate( Object[] args ) throws Exception
177        {
178            Component component = newComponent();
179            return component.getProvider().getValue( false );
180        }
181        
182       /**
183        * Return true if this object is equal to the supplied object.
184        * @param other the object to evaluate
185        * @return the equality status
186        */
187        public boolean equals( Object other )
188        {
189            if( super.equals( other ) && ( other instanceof Composition ) )
190            {
191                Composition composite = (Composition) other;
192                if( !m_directive.equals( composite.m_directive ) )
193                {
194                    return false;
195                }
196                else
197                {
198                    if( null == m_controller )
199                    {
200                        return null == composite.m_controller;
201                    }
202                    else
203                    {
204                        return m_controller.equals( composite.m_controller );
205                    }
206                }
207            }
208            else
209            {
210                return false;
211            }
212        }
213        
214       /**
215        * Return the hashcode for the instance.
216        * @return the instance hashcode
217        */
218        public int hashCode()
219        {
220            int hash = super.hashCode();
221            hash ^= m_directive.hashCode();
222            if( null != m_controller )
223            {
224                hash ^= m_controller.hashCode();
225            }
226            return hash;
227        }
228    }